/**
 * 预测分析页面的主要功能
 */
class PredictionAnalysis {
    constructor() {
        // 图表实例
        this.charts = {
            pricePrediction: null,
            featureImportance: null
        };
        
        // 初始化
        this.init();
    }
    
    /**
     * 初始化
     */
    init() {
        // 等待DOM加载完成
        document.addEventListener('DOMContentLoaded', () => {
            // 初始化图表
            this.initCharts();
            
            // 初始化事件监听
            this.initEventListeners();
        });
    }
    
    /**
     * 初始化图表
     */
    initCharts() {
        // 初始化价格预测趋势图表
        this.initPricePredictionChart();
        
        // 初始化特征重要性图表
        this.initFeatureImportanceChart();
    }
    
    /**
     * 初始化价格预测趋势图表
     */
    initPricePredictionChart() {
        const chartDom = document.getElementById('price-prediction-chart');
        if (!chartDom) return;
        
        this.charts.pricePrediction = echarts.init(chartDom);
        
        // 生成日期数据
        const dates = this.generateDateData(30);
        
        // 生成实际价格数据
        const actualPrices = this.generatePriceData(42.85, 30, 0.5);
        
        // 生成预测价格数据
        const predictedPrices = this.generatePredictedPriceData(actualPrices);
        
        // 生成预测区间上限
        const upperBound = predictedPrices.map(price => price * 1.05);
        
        // 生成预测区间下限
        const lowerBound = predictedPrices.map(price => price * 0.95);
        
        const option = {
            tooltip: {
                trigger: 'axis',
                axisPointer: {
                    type: 'cross',
                    label: {
                        backgroundColor: '#6a7985'
                    }
                }
            },
            legend: {
                data: ['实际价格', '预测价格', '预测区间'],
                top: 0
            },
            grid: {
                left: '3%',
                right: '4%',
                bottom: '3%',
                containLabel: true
            },
            xAxis: {
                type: 'category',
                boundaryGap: false,
                data: dates
            },
            yAxis: {
                type: 'value',
                min: function(value) {
                    return Math.floor(value.min * 0.95);
                },
                max: function(value) {
                    return Math.ceil(value.max * 1.05);
                }
            },
            series: [
                {
                    name: '实际价格',
                    type: 'line',
                    data: actualPrices,
                    symbol: 'circle',
                    symbolSize: 6,
                    lineStyle: {
                        width: 2,
                        color: '#3B82F6'
                    },
                    itemStyle: {
                        color: '#3B82F6'
                    }
                },
                {
                    name: '预测价格',
                    type: 'line',
                    data: predictedPrices,
                    symbol: 'circle',
                    symbolSize: 6,
                    lineStyle: {
                        width: 2,
                        color: '#10B981'
                    },
                    itemStyle: {
                        color: '#10B981'
                    }
                },
                {
                    name: '预测区间',
                    type: 'line',
                    data: upperBound,
                    lineStyle: {
                        opacity: 0
                    },
                    stack: 'confidence-band',
                    symbol: 'none'
                },
                {
                    name: '预测区间',
                    type: 'line',
                    data: lowerBound,
                    lineStyle: {
                        opacity: 0
                    },
                    areaStyle: {
                        color: '#E5E7EB',
                        opacity: 0.4
                    },
                    stack: 'confidence-band',
                    symbol: 'none'
                }
            ]
        };
        
        this.charts.pricePrediction.setOption(option);
        
        // 响应窗口大小变化
        window.addEventListener('resize', () => {
            this.charts.pricePrediction.resize();
        });
    }
    
    /**
     * 初始化特征重要性图表
     */
    initFeatureImportanceChart() {
        const chartDom = document.getElementById('feature-importance-chart');
        if (!chartDom) return;
        
        this.charts.featureImportance = echarts.init(chartDom);
        
        const option = {
            tooltip: {
                trigger: 'axis',
                axisPointer: {
                    type: 'shadow'
                }
            },
            grid: {
                left: '3%',
                right: '4%',
                bottom: '3%',
                containLabel: true
            },
            xAxis: {
                type: 'value',
                max: 100
            },
            yAxis: {
                type: 'category',
                data: ['净资产收益率', '市盈率', 'MACD指标', '市场情绪', '行业趋势', '成交量变化', '现金流'],
                axisLabel: {
                    fontSize: 12
                }
            },
            series: [
                {
                    name: '特征重要性',
                    type: 'bar',
                    data: [85, 76, 72, 68, 65, 58, 52],
                    itemStyle: {
                        color: function(params) {
                            // 根据数值设置不同的颜色
                            const value = params.value;
                            if (value >= 80) {
                                return '#10B981'; // 绿色
                            } else if (value >= 70) {
                                return '#3B82F6'; // 蓝色
                            } else if (value >= 60) {
                                return '#8B5CF6'; // 紫色
                            } else {
                                return '#6B7280'; // 灰色
                            }
                        }
                    },
                    label: {
                        show: true,
                        position: 'right',
                        formatter: '{c}%'
                    }
                }
            ]
        };
        
        this.charts.featureImportance.setOption(option);
        
        // 响应窗口大小变化
        window.addEventListener('resize', () => {
            this.charts.featureImportance.resize();
        });
    }
    
    /**
     * 生成日期数据
     * @param {number} days 天数
     * @returns {Array} 日期数组
     */
    generateDateData(days) {
        const dates = [];
        const now = new Date();
        for (let i = 0; i < days; i++) {
            const date = new Date(now);
            date.setDate(date.getDate() - days + i + 1);
            dates.push(date.toLocaleDateString('zh-CN', { month: 'numeric', day: 'numeric' }));
        }
        return dates;
    }
    
    /**
     * 生成价格数据
     * @param {number} startPrice 起始价格
     * @param {number} days 天数
     * @param {number} volatility 波动率
     * @returns {Array} 价格数组
     */
    generatePriceData(startPrice, days, volatility) {
        const prices = [startPrice];
        for (let i = 1; i < days; i++) {
            const lastPrice = prices[i - 1];
            const change = (Math.random() - 0.5) * 2 * volatility;
            const newPrice = lastPrice * (1 + change);
            prices.push(parseFloat(newPrice.toFixed(2)));
        }
        return prices;
    }
    
    /**
     * 生成预测价格数据
     * @param {Array} actualPrices 实际价格数组
     * @returns {Array} 预测价格数组
     */
    generatePredictedPriceData(actualPrices) {
        // 前20天使用实际价格，后10天使用预测价格
        const predictedPrices = [...actualPrices.slice(0, 20)];
        
        // 生成后10天的预测价格
        const lastActualPrice = actualPrices[19];
        const trend = 0.005; // 假设有轻微上涨趋势
        
        for (let i = 0; i < 10; i++) {
            const lastPrice = predictedPrices[predictedPrices.length - 1];
            const change = trend + (Math.random() - 0.4) * 0.01;
            const newPrice = lastPrice * (1 + change);
            predictedPrices.push(parseFloat(newPrice.toFixed(2)));
        }
        
        return predictedPrices;
    }
    
    /**
     * 初始化事件监听
     */
    initEventListeners() {
        // 时间范围选择
        document.querySelectorAll('[data-time-range]').forEach(button => {
            button.addEventListener('click', (e) => {
                const timeRange = e.currentTarget.dataset.timeRange;
                this.updateTimeRange(timeRange);
                
                // 更新按钮样式
                document.querySelectorAll('[data-time-range]').forEach(btn => {
                    btn.classList.remove('bg-blue-600', 'text-white');
                    btn.classList.add('bg-gray-100', 'text-gray-700');
                });
                e.currentTarget.classList.remove('bg-gray-100', 'text-gray-700');
                e.currentTarget.classList.add('bg-blue-600', 'text-white');
            });
        });
    }
    
    /**
     * 更新时间范围
     * @param {string} range 时间范围
     */
    updateTimeRange(range) {
        console.log('更新时间范围:', range);
        // TODO: 根据选择的时间范围更新图表数据
    }
}

// 创建预测分析实例
window.predictionAnalysis = new PredictionAnalysis();